ஜாவாஸ்கிரிப்டின் இட்டரேட்டர் ஹெல்பர் reduce(): நவீன பயன்பாடுகளுக்கான ஸ்ட்ரீம் ஒருங்கிணைப்பில் தேர்ச்சி பெறுதல்

நவீன வலை மேம்பாட்டின் பரந்த நிலப்பரப்பில், தரவுதான் ராஜா. நிகழ்நேர பகுப்பாய்வு டாஷ்போர்டுகள் முதல் சிக்கலான பின்தள செயலாக்க அமைப்புகள் வரை, தரவு ஸ்ட்ரீம்களை திறமையாக ஒருங்கிணைத்து மாற்றுவதற்கான திறன் மிக முக்கியமானது. இந்த டிஜிட்டல் யுகத்தின் மூலக்கல்லான ஜாவாஸ்கிரிப்ட், தொடர்ந்து வளர்ந்து, டெவலப்பர்களுக்கு மிகவும் சக்திவாய்ந்த மற்றும் எளிமையான கருவிகளை வழங்குகிறது. TC39 முன்மொழிவு செயல்முறையின் மூலம் தற்போது வரும் அத்தகைய ஒரு முன்னேற்றம், இட்டரேட்டர் ஹெல்பர்ஸ் முன்மொழிவு ஆகும், இது மிகவும் எதிர்பார்க்கப்பட்ட reduce() முறையை நேரடியாக இட்டரேட்டர்களுக்கு கொண்டு வருகிறது.

பல ஆண்டுகளாக, டெவலப்பர்கள் Array.prototype.reduce() முறையை அதன் வரிசை உறுப்புகளை ஒரே மதிப்பாக ஒருங்கிணைக்கும் பன்முகத்தன்மைக்காகப் பயன்படுத்தியுள்ளனர். இருப்பினும், பயன்பாடுகள் விரிவடையும்போதும், தரவு எளிய இன்-மெமரி வரிசைகளைத் தாண்டி டைனமிக் ஸ்ட்ரீம்கள் மற்றும் ஒத்திசைவற்ற மூலங்களுக்குச் செல்லும்போதும், ஒரு பொதுவான மற்றும் திறமையான பொறிமுறை தேவைப்படுகிறது. ஜாவாஸ்கிரிப்டின் இட்டரேட்டர் ஹெல்பர் reduce() இங்குதான் நுழைகிறது, இது ஸ்ட்ரீம் ஒருங்கிணைப்பிற்கான ஒரு வலுவான தீர்வை வழங்குகிறது, இது நாம் தரவு செயலாக்கத்தைக் கையாளும் முறையை மாற்றியமைக்கும் என்று உறுதியளிக்கிறது.

இந்த விரிவான வழிகாட்டி Iterator.prototype.reduce() இன் நுணுக்கங்களை ஆராயும், அதன் முக்கிய செயல்பாடு, நடைமுறை பயன்பாடுகள், செயல்திறன் நன்மைகள் மற்றும் உலகெங்கிலும் உள்ள டெவலப்பர்களுக்கு அதிக நெகிழ்வான மற்றும் அளவிடக்கூடிய அமைப்புகளை உருவாக்க இது எவ்வாறு அதிகாரம் அளிக்கிறது என்பதை ஆராயும்.

reduce() இன் பரிணாமம்: வரிசைகளிலிருந்து இட்டரேட்டர்கள் வரை

Iterator.prototype.reduce() இன் முக்கியத்துவத்தை உண்மையாகப் பாராட்ட, அதன் வம்சாவளியையும் அது தீர்க்கும் சிக்கல்களையும் புரிந்துகொள்வது அவசியம். ஒரு தொகுப்பை ஒரே மதிப்பாக "குறைப்பது" என்ற கருத்து செயல்பாட்டு நிரலாக்கத்தில் ஒரு அடிப்படை வடிவமாகும், இது சக்திவாய்ந்த தரவு மாற்றங்களை செயல்படுத்துகிறது.

Array.prototype.reduce(): ஒரு பழக்கமான அடித்தளம்

பெரும்பாலான ஜாவாஸ்கிரிப்ட் டெவலப்பர்கள் Array.prototype.reduce() உடன் நன்கு பரிச்சயமானவர்கள். ES5 இன் ஒரு பகுதியாக அறிமுகப்படுத்தப்பட்ட இது, எண்களைக் கூட்டுதல், நிகழ்வுகளை எண்ணுதல், வரிசைகளைத் தட்டையாக்குதல் அல்லது பொருட்களின் வரிசையை ஒரே, ஒருங்கிணைந்த பொருளாக மாற்றுதல் போன்ற பணிகளுக்கு விரைவாக ஒரு பிரதானமாக மாறியது. அதன் கையொப்பம் மற்றும் நடத்தை நன்கு புரிந்து கொள்ளப்பட்டது:

            const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
// sum is 15

const items = [{ id: 'a', value: 10 }, { id: 'b', value: 20 }, { id: 'c', value: 30 }];
const totalValue = items.reduce((acc, item) => acc + item.value, 0);
// totalValue is 60

const groupedById = items.reduce((acc, item) => {
  acc[item.id] = item.value;
  return acc;
}, {});
// groupedById is { a: 10, b: 20, c: 30 }
            

              
                Copy
              
            
          

நம்பமுடியாத அளவிற்கு சக்திவாய்ந்ததாக இருந்தாலும், Array.prototype.reduce() பிரத்தியேகமாக வரிசைகளில் செயல்படுகிறது. இதன் பொருள், உங்கள் தரவு ஒரு ஜெனரேட்டர் செயல்பாடு, ஒரு தனிப்பயன் இட்டரபிள் அல்லது ஒரு ஒத்திசைவற்ற ஸ்ட்ரீமிலிருந்து உருவானால், நீங்கள் பொதுவாக அதை முதலில் ஒரு வரிசையாக மாற்ற வேண்டும் (எ.கா., Array.from() அல்லது ஸ்ப்ரெட் ஆபரேட்டர் [...] ஐப் பயன்படுத்தி). சிறிய தரவுத்தொகுப்புகளுக்கு, இது ஒரு பிரச்சினை அல்ல. இருப்பினும், பெரிய அல்லது எல்லையற்ற தரவு ஸ்ட்ரீம்களுக்கு, முழு தரவுத்தொகுப்பையும் நினைவகத்தில் ஒரு வரிசையாகப் பொருளாக்குவது திறமையற்றதாக, நினைவகத்தை அதிகம் பயன்படுத்துவதாக அல்லது சாத்தியமற்றதாக இருக்கலாம்.

இட்டரேட்டர்கள் மற்றும் ஒத்திசைவற்ற இட்டரேட்டர்களின் எழுச்சி

ES6 உடன், ஜாவாஸ்கிரிப்ட் இட்டரேட்டர் நெறிமுறையை அறிமுகப்படுத்தியது, இது பொருள்கள் எவ்வாறு திரும்பத் திரும்பச் செயலாக்கப்படலாம் என்பதை வரையறுப்பதற்கான ஒரு தரப்படுத்தப்பட்ட வழியாகும். ஜெனரேட்டர் செயல்பாடுகள் (function*) தனிப்பயன் இட்டரேட்டர்களை உருவாக்குவதற்கான ஒரு சக்திவாய்ந்த பொறிமுறையாக மாறியது, அவை முழுத் தொகுப்பையும் நினைவகத்தில் சேமிக்கத் தேவையில்லாமல், ஒரு நேரத்தில் ஒரு மதிப்பை சோம்பேறித்தனமாக உருவாக்குகின்றன. இது நினைவகத் திறன் மற்றும் பெரிய தரவுத்தொகுப்புகளைக் கையாள்வதில் ஒரு கேம்-சேஞ்சராக இருந்தது.

            function* generateEvenNumbers(limit) {
  let num = 0;
  while (num <= limit) {
    yield num;
    num += 2;
  }
}

const evenNumbersIterator = generateEvenNumbers(10);
// Now, how do we reduce this iterator without converting to an array?
            

              
                Copy
              
            
          

பின்னர், ES2018 ஒத்திசைவற்ற இட்டரேட்டர்களை (async function* மற்றும் for await...of சுழற்சிகள்) கொண்டு வந்தது, இந்த சோம்பேறி, வரிசைமுறை செயலாக்கத் திறனை நெட்வொர்க் கோரிக்கைகள், தரவுத்தள கர்சர்கள் அல்லது கோப்பு ஸ்ட்ரீம்கள் போன்ற ஒத்திசைவற்ற தரவு மூலங்களுக்கு விரிவுபடுத்தியது. இது காலப்போக்கில் வரும் சாத்தியமான மகத்தான அளவிலான தரவைக் கையாள உதவியது, பிரதான த்ரெட்டைத் தடுக்காமல்.

            async function* fetchUserIDs(apiBaseUrl) {
  let page = 1;
  while (true) {
    const response = await fetch(`${apiBaseUrl}/users?page=${page}`);
    const data = await response.json();
    if (data.users.length === 0) break;
    for (const user of data.users) {
      yield user.id;
    }
    page++;
  }
}
            

              
                Copy
              
            
          

map, filter, reduce, மற்றும் பிற பொதுவான வரிசை முறைகள் நேரடியாக இட்டரேட்டர்கள் மற்றும் ஒத்திசைவற்ற இட்டரேட்டர்களில் இல்லாதது ஒரு குறிப்பிடத்தக்க இடைவெளியாக உள்ளது. டெவலப்பர்கள் பெரும்பாலும் தனிப்பயன் சுழற்சிகள், உதவி நூலகங்கள் அல்லது திறமையற்ற வரிசை மாற்றும் தந்திரத்தை நாடினர். இட்டரேட்டர் ஹெல்பர்ஸ் முன்மொழிவு இந்த இடைவெளியைக் குறைப்பதை நோக்கமாகக் கொண்டுள்ளது, இது மிகவும் எதிர்பார்க்கப்பட்ட reduce() உட்பட, நிலையான மற்றும் செயல்திறன் மிக்க முறைகளின் தொகுப்பை வழங்குகிறது.

ஜாவாஸ்கிரிப்டின் இட்டரேட்டர் ஹெல்பர் reduce() ஐப் புரிந்துகொள்வது

இட்டரேட்டர் ஹெல்பர்ஸ் முன்மொழிவு (தற்போது TC39 செயல்முறையின் நிலை 3 இல் உள்ளது, இது மொழியில் சேர்க்கப்படுவதற்கான வலுவான வாய்ப்பைக் குறிக்கிறது) Iterator.prototype மற்றும் AsyncIterator.prototype இல் நேரடியாக முறைகளின் தொகுப்பை அறிமுகப்படுத்துகிறது. இதன் பொருள், இட்டரேட்டர் நெறிமுறையைப் பின்பற்றும் எந்தவொரு பொருளும் (ஜெனரேட்டர் செயல்பாடுகள், தனிப்பயன் இட்டரபிள்கள், மற்றும் மறைமுகமாக வரிசைகள் உட்பட) இப்போது இந்த சக்திவாய்ந்த பயன்பாடுகளை நேரடியாகப் பயன்படுத்த முடியும்.

இட்டரேட்டர் ஹெல்பர்கள் என்றால் என்ன?

இட்டரேட்டர் ஹெல்பர்கள் ஒத்திசைவான மற்றும் ஒத்திசைவற்ற இட்டரேட்டர்களுடன் தடையின்றி வேலை செய்ய வடிவமைக்கப்பட்ட பயன்பாட்டு முறைகளின் தொகுப்பாகும். அவை மதிப்புகளின் வரிசைகளை மாற்றுவதற்கும், வடிகட்டுவதற்கும், ஒருங்கிணைப்பதற்கும் ஒரு செயல்பாட்டு, அறிவிப்பு வழியை வழங்குகின்றன. அவற்றை Array.prototype முறைகளாக நினைத்துப் பாருங்கள், ஆனால் எந்தவொரு இட்டரபிள் வரிசைக்கும், சோம்பேறித்தனமாகவும் திறமையாகவும் நுகரப்படும். இது பல்வேறு தரவு மூலங்களுடன் பணிபுரிவதற்கான பணிச்சூழலியல் மற்றும் செயல்திறனை கணிசமாக மேம்படுத்துகிறது.

முக்கிய முறைகள் பின்வருமாறு:

• .map(mapperFunction)
• .filter(predicateFunction)
• .take(count)
• .drop(count)
• .toArray()
• .forEach(callback)
• மற்றும், நிச்சயமாக, .reduce(reducerFunction, initialValue)

இங்குள்ள மகத்தான நன்மை நிலைத்தன்மையாகும். உங்கள் தரவு ஒரு எளிய வரிசையிலிருந்து, ஒரு சிக்கலான ஜெனரேட்டரிலிருந்து அல்லது ஒரு ஒத்திசைவற்ற நெட்வொர்க் ஸ்ட்ரீமிலிருந்து வந்தாலும், பொதுவான செயல்பாடுகளுக்கு நீங்கள் அதே வெளிப்படையான தொடரியலைப் பயன்படுத்தலாம், இது அறிவாற்றல் சுமையைக் குறைத்து குறியீடு பராமரிப்பை மேம்படுத்துகிறது.

reduce() கையொப்பம் மற்றும் அது எவ்வாறு செயல்படுகிறது

Iterator.prototype.reduce() முறையின் கையொப்பம் அதன் வரிசை எண்ணுக்கு மிகவும் ஒத்திருக்கிறது, இது டெவலப்பர்களுக்கு ஒரு பழக்கமான அனுபவத்தை உறுதி செய்கிறது:

            iterator.reduce(reducerFunction, initialValue)
            

              
                Copy
              
            
          

• reducerFunction (தேவை): இட்டரேட்டரில் உள்ள ஒவ்வொரு உறுப்புக்கும் ஒருமுறை செயல்படுத்தப்படும் ஒரு கால்பேக் செயல்பாடு. இது இரண்டு (அல்லது மூன்று) வாதங்களை எடுக்கும்:
  • accumulator: reducerFunction இன் முந்தைய அழைப்பிலிருந்து வரும் மதிப்பு. முதல் அழைப்பில், இது initialValue அல்லது இட்டரேட்டரின் முதல் உறுப்பு ஆகும்.
  • currentValue: இட்டரேட்டரிலிருந்து செயலாக்கப்படும் தற்போதைய உறுப்பு.
  • currentIndex (விருப்பத்தேர்வு): இட்டரேட்டரில் currentValue இன் குறியீட்டெண். உள்ளார்ந்த குறியீடுகளைக் கொண்டிராத பொதுவான இட்டரேட்டர்களுக்கு இது குறைவாகவே உள்ளது, ஆனால் இது கிடைக்கிறது.
• initialValue (விருப்பத்தேர்வு): reducerFunction இன் முதல் அழைப்பிற்கு முதல் வாதமாகப் பயன்படுத்தப்படும் ஒரு மதிப்பு. initialValue வழங்கப்படாவிட்டால், இட்டரேட்டரின் முதல் உறுப்பு accumulator ஆகிறது, மேலும் reducerFunction இரண்டாவது உறுப்பிலிருந்து செயல்படுத்தத் தொடங்குகிறது.

வெற்று இட்டரேட்டர்களுடனான பிழைகளைத் தவிர்க்கவும், உங்கள் ஒருங்கிணைப்பின் தொடக்க வகையை வெளிப்படையாக வரையறுக்கவும் எப்போதும் ஒரு initialValue ஐ வழங்குவது பொதுவாக பரிந்துரைக்கப்படுகிறது. இட்டரேட்டர் காலியாக இருந்து initialValue வழங்கப்படாவிட்டால், reduce() ஒரு TypeError ஐ வீசும்.

ஒரு ஜெனரேட்டர் செயல்பாட்டுடன் இது எவ்வாறு செயல்படுகிறது என்பதைக் காட்டும் ஒரு அடிப்படை ஒத்திசைவான எடுத்துக்காட்டுடன் விளக்குவோம்:

            // Code Example 1: Basic Numeric Aggregation (Sync Iterator)

// A generator function creating an iterable sequence
function* generateNumbers(limit) {
  console.log('Generator started');
  for (let i = 1; i <= limit; i++) {
    console.log(`Yielding ${i}`);
    yield i;
  }
  console.log('Generator finished');
}

// Create an iterator instance
const numbersIterator = generateNumbers(5);

// Use the new Iterator Helper reduce method
const sum = numbersIterator.reduce((accumulator, currentValue) => {
  console.log(`Reducing: acc=${accumulator}, val=${currentValue}`);
  return accumulator + currentValue;
}, 0);

console.log(`\nFinal Sum: ${sum}`);

/*
Expected Output:
Generator started
Yielding 1
Reducing: acc=0, val=1
Yielding 2
Reducing: acc=1, val=2
Yielding 3
Reducing: acc=3, val=3
Yielding 4
Reducing: acc=6, val=4
Yielding 5
Reducing: acc=10, val=5
Generator finished

Final Sum: 15
*/
            

              
                Copy
              
            
          

`console.log` அறிக்கைகள் சோம்பேறி மதிப்பீட்டை எவ்வாறு நிரூபிக்கின்றன என்பதைக் கவனியுங்கள்: `reduce()` அடுத்த மதிப்பைக் கோரும்போது மட்டுமே `Yielding` நிகழ்கிறது, அதன்பிறகு உடனடியாக `Reducing` நிகழ்கிறது. இது நினைவகத் திறனை எடுத்துக்காட்டுகிறது – இட்டரேட்டரிலிருந்து ஒரே ஒரு மதிப்பு மட்டுமே ஒரு நேரத்தில் நினைவகத்தில் உள்ளது, `accumulator` உடன் சேர்ந்து.

நடைமுறை பயன்பாடுகள் மற்றும் பயன்பாட்டு வழக்குகள்

Iterator.prototype.reduce() இன் உண்மையான சக்தி நிஜ உலக сценарияக்களில், குறிப்பாக தரவு ஸ்ட்ரீம்கள், பெரிய தரவுத்தொகுப்புகள் மற்றும் ஒத்திசைவற்ற செயல்பாடுகளைக் கையாளும் போது பிரகாசிக்கிறது. தரவை படிப்படியாக செயலாக்கும் அதன் திறன் நவீன பயன்பாட்டு வளர்ச்சிக்கு ஒரு தவிர்க்க முடியாத கருவியாக அமைகிறது.

பெரிய தரவுத்தொகுப்புகளை திறமையாக செயலாக்குதல் (நினைவக தடம்)

இட்டரேட்டர் ஹெல்பர்களுக்கான மிகவும் கட்டாயக் காரணங்களில் ஒன்று அவற்றின் நினைவகத் திறன். பாரம்பரிய வரிசை முறைகளுக்கு பெரும்பாலும் முழு தரவுத்தொகுப்பையும் நினைவகத்தில் ஏற்ற வேண்டும், இது ஜிகாபைட்களைக் கொண்ட கோப்புகள் அல்லது முடிவற்ற தரவு ஸ்ட்ரீம்களுக்கு சிக்கலானது. இட்டரேட்டர்கள், வடிவமைப்பால், மதிப்புகளை ஒவ்வொன்றாக செயலாக்குகின்றன, நினைவகத் தடத்தை மிகக் குறைவாக வைத்திருக்கின்றன.

மில்லியன் கணக்கான பதிவுகளைக் கொண்ட ஒரு பெரிய CSV கோப்பை பகுப்பாய்வு செய்யும் பணியைக் கவனியுங்கள். இந்த முழு கோப்பையும் ஒரு வரிசையில் ஏற்றினால், உங்கள் பயன்பாடு விரைவில் நினைவகத்தை இழக்கக்கூடும். இட்டரேட்டர்களுடன், நீங்கள் இந்தத் தரவை துண்டுகளாகப் பிரித்து ஒருங்கிணைக்கலாம்.

            // Example: Aggregating Sales Data from a Large CSV Stream (Conceptual)

// A conceptual function that yields rows from a CSV file line by line
// In a real application, this might read from a file stream or network buffer.
function* parseCSVStream(csvContent) {
  const lines = csvContent.trim().split('\n');
  const headers = lines[0].split(',');
  for (let i = 1; i < lines.length; i++) {
    const values = lines[i].split(',');
    const row = {};
    for (let j = 0; j < headers.length; j++) {
      row[headers[j].trim()] = values[j].trim();
    }
    yield row;
  }
}

const largeCSVData = "Product,Category,Price,Quantity,Date\nLaptop,Electronics,1200,1,2023-01-15\nMouse,Electronics,25,2,2023-01-16\nKeyboard,Electronics,75,1,2023-01-15\nDesk,Furniture,300,1,2023-01-17\nChair,Furniture,150,2,2023-01-18\nLaptop,Electronics,1300,1,2023-02-01";

const salesIterator = parseCSVStream(largeCSVData);

// Aggregate total sales value per category
const salesByCategory = salesIterator.reduce((acc, row) => {
  const category = row.Category;
  const price = parseFloat(row.Price);
  const quantity = parseInt(row.Quantity, 10);
  
  if (acc[category]) {
    acc[category] += price * quantity;
  } else {
    acc[category] = price * quantity;
  }
  return acc;
}, {});

console.log(salesByCategory);
/*
Expected Output (approximated for example):
{
  Electronics: 2625, 
  Furniture: 600
}
*/
            

              
                Copy
              
            
          

இந்த கருத்தியல் எடுத்துக்காட்டில், `parseCSVStream` ஜெனரேட்டர் ஒவ்வொரு வரிசைப் பொருளையும் ஒவ்வொன்றாக அளிக்கிறது. `reduce()` முறையானது இந்த வரிசைப் பொருள்கள் கிடைக்கும்போது அவற்றைச் செயலாக்குகிறது, முழு `largeCSVData`-வையும் ஒரு பொருள் வரிசையில் ஒருபோதும் வைத்திருக்காமல். இந்த "ஸ்ட்ரீம் ஒருங்கிணைப்பு" முறை பெரிய தரவுகளைக் கையாளும் பயன்பாடுகளுக்கு விலைமதிப்பற்றது, இது குறிப்பிடத்தக்க நினைவகச் சேமிப்பையும் மேம்பட்ட செயல்திறனையும் வழங்குகிறது.

asyncIterator.reduce() உடன் ஒத்திசைவற்ற ஸ்ட்ரீம் ஒருங்கிணைப்பு

ஒத்திசைவற்ற இட்டரேட்டர்களை reduce() செய்யும் திறன் இட்டரேட்டர் ஹெல்பர்ஸ் முன்மொழிவின் மிகவும் சக்திவாய்ந்த அம்சங்களில் ஒன்றாகும். நவீன பயன்பாடுகள் அடிக்கடி வெளிப்புற சேவைகள், தரவுத்தளங்கள் மற்றும் APIகளுடன் தொடர்பு கொள்கின்றன, பெரும்பாலும் தரவுகளைப் பக்கப்படுத்தப்பட்ட அல்லது ஸ்ட்ரீமிங் வடிவங்களில் பெறுகின்றன. ஒத்திசைவற்ற இட்டரேட்டர்கள் இதற்கு மிகவும் பொருத்தமானவை, மேலும் asyncIterator.reduce() இந்த உள்வரும் தரவுத் துண்டுகளை ஒருங்கிணைக்க ஒரு சுத்தமான, அறிவிப்பு வழியை வழங்குகிறது.

            // Code Example 2: Aggregating Data from a Paginated API (Async Iterator)

// A mock asynchronous generator that simulates fetching paginated user data
async function* fetchPaginatedUserData(apiBaseUrl, initialPage = 1, limit = 2) {
  let currentPage = initialPage;
  while (true) {
    console.log(`Fetching data for page ${currentPage}...`);
    // Simulate API call delay
    await new Promise(resolve => setTimeout(resolve, 500)); 
    
    // Mock API response
    const data = {
      1: [{ id: 'u1', name: 'Alice' }, { id: 'u2', name: 'Bob' }],
      2: [{ id: 'u3', name: 'Charlie' }, { id: 'u4', name: 'David' }],
      3: [{ id: 'u5', name: 'Eve' }],
      4: [] // Simulate end of data
    }[currentPage];

    if (!data || data.length === 0) {
      console.log('No more data to fetch.');
      break;
    }
    
    console.log(`Yielding ${data.length} users from page ${currentPage}`);
    yield data; // Yield an array of users for the current page
    
    currentPage++;
    if (currentPage > limit) break; // For demonstration, limit pages
  }
}

// Create an async iterator instance
const usersIterator = fetchPaginatedUserData('https://api.example.com', 1, 3); // Fetch 3 pages

// Aggregate all user names into a single array
const allUserNames = await usersIterator.reduce(async (accumulator, pageUsers) => {
  const names = pageUsers.map(user => user.name);
  return accumulator.concat(names);
}, []);

console.log(`\nAggregated User Names:`, allUserNames);
/*
Expected Output (with delays):
Fetching data for page 1...
Yielding 2 users from page 1
Fetching data for page 2...
Yielding 2 users from page 2
Fetching data for page 3...
Yielding 1 users from page 3
No more data to fetch.

Aggregated User Names: [ 'Alice', 'Bob', 'Charlie', 'David', 'Eve' ]
*/
            

              
                Copy
              
            
          

இங்கே, `reducerFunction` தானே `async` ஆகும், இது ஒவ்வொரு பக்கத்தின் தரவுகளின் ஒருங்கிணைப்பிற்காக காத்திருக்க அனுமதிக்கிறது. reduce() அழைப்பு தானே `await` செய்யப்பட வேண்டும், ஏனெனில் அது ஒரு ஒத்திசைவற்ற வரிசையைச் செயலாக்குகிறது. இந்த முறை போன்ற сценарияக்களுக்கு நம்பமுடியாத அளவிற்கு சக்தி வாய்ந்தது:

• பல விநியோகிக்கப்பட்ட சேவைகளிலிருந்து மெட்ரிக்குகளை சேகரித்தல்.
• ஒரே நேரத்தில் தரவுத்தள வினவல்களின் முடிவுகளை ஒருங்கிணைத்தல்.
• ஒரு நெட்வொர்க் வழியாக ஸ்ட்ரீம் செய்யப்படும் பெரிய பதிவு கோப்புகளை செயலாக்குதல்.

சிக்கலான தரவு மாற்றங்கள் மற்றும் அறிக்கையிடல்

reduce() என்பது எண்களைக் கூட்டுவதற்கோ அல்லது வரிசைகளை இணைப்பதற்கோ மட்டுமல்ல. இது சிக்கலான தரவுக் கட்டமைப்புகளை உருவாக்குவதற்கும், அதிநவீன ஒருங்கிணைப்புகளைச் செய்வதற்கும், மூல தரவு ஸ்ட்ரீம்களிலிருந்து அறிக்கைகளை உருவாக்குவதற்கும் ஒரு பல்துறை கருவியாகும். `accumulator` எந்த வகையாகவும் இருக்கலாம் – ஒரு பொருள், ஒரு வரைபடம், ஒரு தொகுப்பு அல்லது மற்றொரு இட்டரேட்டர் கூட – இது மிகவும் நெகிழ்வான மாற்றங்களை அனுமதிக்கிறது.

            // Example: Grouping Transactions by Currency and Calculating Totals

// A generator for transaction data
function* getTransactions() {
  yield { id: 'T001', amount: 100, currency: 'USD', status: 'completed' };
  yield { id: 'T002', amount: 50, currency: 'EUR', status: 'pending' };
  yield { id: 'T003', amount: 120, currency: 'USD', status: 'completed' };
  yield { id: 'T004', amount: 75, currency: 'GBP', status: 'completed' };
  yield { id: 'T005', amount: 200, currency: 'EUR', status: 'completed' };
  yield { id: 'T006', amount: 30, currency: 'USD', status: 'failed' };
}

const transactionsIterator = getTransactions();

const currencySummary = transactionsIterator.reduce((acc, transaction) => {
  // Initialize currency entry if it doesn't exist
  if (!acc[transaction.currency]) {
    acc[transaction.currency] = { totalAmount: 0, completedTransactions: 0, pendingTransactions: 0 };
  }

  // Update total amount
  acc[transaction.currency].totalAmount += transaction.amount;

  // Update status-specific counts
  if (transaction.status === 'completed') {
    acc[transaction.currency].completedTransactions++;
  } else if (transaction.status === 'pending') {
    acc[transaction.currency].pendingTransactions++;
  }

  return acc;
}, {}); // Initial accumulator is an empty object

console.log(currencySummary);
/*
Expected Output:
{
  USD: { totalAmount: 250, completedTransactions: 2, pendingTransactions: 0 },
  EUR: { totalAmount: 250, completedTransactions: 1, pendingTransactions: 1 },
  GBP: { totalAmount: 75, completedTransactions: 1, pendingTransactions: 0 }
}
*/
            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டு, மூல பரிவர்த்தனை தரவுகளின் ஸ்ட்ரீமிலிருந்து ஒரு வளமான, கட்டமைக்கப்பட்ட அறிக்கையை உருவாக்க reduce() எவ்வாறு பயன்படுத்தப்படலாம் என்பதைக் காட்டுகிறது. இது நாணயத்தின் அடிப்படையில் குழுவாக்கி, ஒவ்வொரு குழுவிற்கும் பல மெட்ரிக்குகளைக் கணக்கிடுகிறது, அனைத்தும் இட்டரேட்டரில் ஒரே பாஸில். டாஷ்போர்டுகள், பகுப்பாய்வுகள் மற்றும் சுருக்கக் காட்சிகளை உருவாக்குவதற்கு இந்த முறை நம்பமுடியாத அளவிற்கு நெகிழ்வானது.

பிற இட்டரேட்டர் ஹெல்பர்களுடன் இணைத்தல்

இட்டரேட்டர் ஹெல்பர்களின் மிகவும் நேர்த்தியான அம்சங்களில் ஒன்று அவற்றின் இயற்றக்கூடிய தன்மையாகும். வரிசை முறைகளைப் போலவே, அவற்றை ஒன்றாகச் சங்கிலியிடலாம், இது மிகவும் படிக்கக்கூடிய மற்றும் அறிவிப்பு தரவு செயலாக்க குழாய்களை உருவாக்குகிறது. இது இடைநிலை வரிசைகளை உருவாக்காமல், ஒரு தரவு ஸ்ட்ரீமில் திறமையாக பல மாற்றங்களைச் செய்ய உங்களை அனுமதிக்கிறது.

            // Example: Filtering, Mapping, then Reducing a Stream

function* getAllProducts() {
  yield { name: 'Laptop Pro', price: 1500, category: 'Electronics', rating: 4.8 };
  yield { name: 'Ergonomic Chair', price: 400, category: 'Furniture', rating: 4.5 };
  yield { name: 'Smartwatch X', price: 300, category: 'Electronics', rating: 4.2 };
  yield { name: 'Gaming Keyboard', price: 120, category: 'Electronics', rating: 4.7 };
  yield { name: 'Office Desk', price: 250, category: 'Furniture', rating: 4.1 };
}

const productsIterator = getAllProducts();

// Find the average price of high-rated (>= 4.5) electronics products
const finalResult = productsIterator
  .filter(product => product.category === 'Electronics' && product.rating >= 4.5)
  .map(product => product.price)
  .reduce((acc, price) => {
    acc.total += price;
    acc.count++;
    return acc;
  }, { total: 0, count: 0 });

const avgPrice = finalResult.count > 0 ? finalResult.total / finalResult.count : 0;

console.log(`\nAverage price of high-rated electronics: ${avgPrice.toFixed(2)}`);
/*
Expected Output:
Average price of high-rated electronics: 810.00
(Laptop Pro: 1500, Gaming Keyboard: 120 -> (1500+120)/2 = 810)
*/
            

              
                Copy
              
            
          

இந்த சங்கிலி முதலில் குறிப்பிட்ட தயாரிப்புகளுக்கு `filter` செய்கிறது, பின்னர் அவற்றை அவற்றின் விலைகளுக்கு `map` செய்கிறது, இறுதியாக சராசரியைக் கணக்கிட விளைந்த விலைகளை `reduce` செய்கிறது. ஒவ்வொரு செயல்பாடும் சோம்பேறித்தனமாகச் செய்யப்படுகிறது, இடைநிலை வரிசைகளை உருவாக்காமல், குழாய் முழுவதும் உகந்த நினைவகப் பயன்பாட்டைப் பராமரிக்கிறது. இந்த அறிவிப்பு பாணி செயல்திறனை மேம்படுத்துவதோடு மட்டுமல்லாமல், குறியீடு வாசிப்பு மற்றும் பராமரிப்பையும் மேம்படுத்துகிறது, இது டெவலப்பர்கள் சிக்கலான தரவு ஓட்டங்களை சுருக்கமாக வெளிப்படுத்த அனுமதிக்கிறது.

செயல்திறன் பரிசீலனைகள் மற்றும் சிறந்த நடைமுறைகள்

Iterator.prototype.reduce() குறிப்பிடத்தக்க நன்மைகளை வழங்கினாலும், அதன் நுணுக்கங்களைப் புரிந்துகொண்டு சிறந்த நடைமுறைகளைப் பின்பற்றுவது அதன் முழுத் திறனையும் பயன்படுத்தவும் பொதுவான ஆபத்துக்களைத் தவிர்க்கவும் உதவும்.

சோம்பேறித்தனம் மற்றும் நினைவகத் திறன்: ஒரு முக்கிய நன்மை

இட்டரேட்டர்கள் மற்றும் அவற்றின் ஹெல்பர்களின் முக்கிய நன்மை அவற்றின் சோம்பேறி மதிப்பீடு ஆகும். முழுத் தொகுப்பையும் ஒரே நேரத்தில் திரும்பத் திரும்பச் செயலாக்கும் வரிசை முறைகளைப் போலல்லாமல், இட்டரேட்டர் ஹெல்பர்கள் கோரப்படும்போது மட்டுமே உருப்படிகளைச் செயலாக்குகின்றன. இதன் பொருள்:

• குறைக்கப்பட்ட நினைவகத் தடம்: பெரிய தரவுத்தொகுப்புகளுக்கு, ஒரு நேரத்தில் ஒரு உருப்படி (மற்றும் அக்குமுலேட்டர்) மட்டுமே நினைவகத்தில் வைக்கப்படுகிறது, இது நினைவகச் சோர்வைத் தடுக்கிறது.
• முன்கூட்டியே வெளியேறும் சாத்தியம்: நீங்கள் reduce() ஐ take() அல்லது find() (மற்றொரு ஹெல்பர்) போன்ற முறைகளுடன் இணைத்தால், விரும்பிய முடிவு கிடைத்தவுடன் திரும்பத் திரும்பச் செயலாக்குவது நிறுத்தப்படலாம், இது தேவையற்ற செயலாக்கத்தைத் தவிர்க்கிறது.

இந்த சோம்பேறி நடத்தை எல்லையற்ற ஸ்ட்ரீம்கள் அல்லது நினைவகத்தில் பொருந்தாத அளவுக்கு பெரிய தரவைக் கையாள்வதற்கு முக்கியமானது, இது உங்கள் பயன்பாடுகளை மிகவும் வலுவானதாகவும் திறமையாகவும் ஆக்குகிறது.

குறைப்பான்களில் மாறாத்தன்மை எதிராக மாற்றம்

செயல்பாட்டு நிரலாக்கத்தில், reduce பெரும்பாலும் மாறாத்தன்மையுடன் தொடர்புடையது, அங்கு `reducerFunction` இருக்கும் ஒன்றை மாற்றுவதை விட ஒரு புதிய அக்குமுலேட்டர் நிலையைத் திருப்புகிறது. எளிய மதிப்புகள் (எண்கள், சரங்கள்) அல்லது சிறிய பொருள்களுக்கு, ஒரு புதிய பொருளைத் திருப்புவது (எ.கா., ஸ்ப்ரெட் தொடரியலைப் பயன்படுத்தி { ...acc, newProp: value }) ஒரு சுத்தமான மற்றும் பாதுகாப்பான அணுகுமுறையாகும்.

            // Immutable approach: preferred for clarity and avoiding side effects
const immutableSum = numbersIterator.reduce((acc, val) => acc + val, 0);

const groupedImmutable = transactionsIterator.reduce((acc, transaction) => ({
  ...acc,
  [transaction.currency]: { 
    ...acc[transaction.currency],
    totalAmount: (acc[transaction.currency]?.totalAmount || 0) + transaction.amount
  }
}), {});
            

              
                Copy
              
            
          

இருப்பினும், மிக பெரிய அக்குமுலேட்டர் பொருள்கள் அல்லது செயல்திறன்-முக்கியமான сценарияக்களுக்கு, அக்குமுலேட்டரை நேரடியாக மாற்றுவது அதிக செயல்திறன் மிக்கதாக இருக்கலாம், ஏனெனில் இது ஒவ்வொரு திரும்பத் திரும்பச் செயலாக்கத்திலும் புதிய பொருள்களை உருவாக்கும் மேல்நிலையைத் தவிர்க்கிறது. நீங்கள் மாற்றத்தைத் தேர்ந்தெடுக்கும்போது, உங்கள் குறியீட்டில் வேறு எங்கும் எதிர்பாராத பக்க விளைவுகளைத் தடுக்க இது `reducerFunction`-க்குள் தெளிவாக ஆவணப்படுத்தப்பட்டு இணைக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும்.

            // Mutable approach: potentially more performant for very large objects, use with caution
const groupedMutable = transactionsIterator.reduce((acc, transaction) => {
  if (!acc[transaction.currency]) {
    acc[transaction.currency] = { totalAmount: 0 };
  }
  acc[transaction.currency].totalAmount += transaction.amount;
  return acc;
}, {});
            

              
                Copy
              
            
          

உங்கள் குறிப்பிட்ட பயன்பாட்டின் தேவைகளின் அடிப்படையில் தெளிவு/பாதுகாப்பு (மாறாத்தன்மை) மற்றும் மூல செயல்திறன் (மாற்றம்) ஆகியவற்றுக்கு இடையேயான வர்த்தகங்களை எப்போதும் எடைபோடுங்கள்.

சரியான initialValue ஐத் தேர்ந்தெடுப்பது

முன்னர் குறிப்பிட்டபடி, ஒரு initialValue ஐ வழங்குவது மிகவும் பரிந்துரைக்கப்படுகிறது. இது ஒரு வெற்று இட்டரேட்டரைக் குறைக்கும்போது பிழைகளிலிருந்து பாதுகாப்பது மட்டுமல்லாமல், உங்கள் அக்குமுலேட்டரின் தொடக்க வகை மற்றும் கட்டமைப்பை தெளிவாக வரையறுக்கிறது. இது குறியீடு வாசிப்பை மேம்படுத்துகிறது மற்றும் உங்கள் reduce() செயல்பாடுகளை மிகவும் கணிக்கக்கூடியதாக ஆக்குகிறது.

            // Good: Explicit initial value
const sum = generateNumbers(0).reduce((acc, val) => acc + val, 0); // sum will be 0, no error

// Bad: No initial value, will throw TypeError for empty iterator
// const sumError = generateNumbers(0).reduce((acc, val) => acc + val); // Throws TypeError
            

              
                Copy
              
            
          

உங்கள் இட்டரேட்டர் காலியாக இருக்காது என்று நீங்கள் உறுதியாக இருந்தாலும், initialValue ஐ வரையறுப்பது ஒருங்கிணைக்கப்பட்ட முடிவின் எதிர்பார்க்கப்படும் வடிவத்திற்கான நல்ல ஆவணமாக செயல்படுகிறது.

ஸ்ட்ரீம்களில் பிழை கையாளுதல்

இட்டரேட்டர்களுடன், குறிப்பாக ஒத்திசைவற்றவற்றுடன் பணிபுரியும் போது, பல்வேறு புள்ளிகளில் பிழைகள் ஏற்படலாம்: மதிப்பு உருவாக்கும் போது (எ.கா., ஒரு `async function*`-ல் ஒரு நெட்வொர்க் பிழை), அல்லது `reducerFunction`-க்குள்ளேயே. பொதுவாக, இட்டரேட்டரின் `next()` முறை அல்லது `reducerFunction`-ல் கையாளப்படாத விதிவிலக்கு திரும்பத் திரும்பச் செயலாக்குவதை நிறுத்தி பிழையைப் பரப்பும். `asyncIterator.reduce()` க்கு, இதன் பொருள் `await` அழைப்பு ஒரு பிழையை வீசும், அதை `try...catch` ஐப் பயன்படுத்திப் பிடிக்கலாம்:

            async function* riskyGenerator() {
  yield 1;
  throw new Error('Something went wrong during generation!');
  yield 2; // This will never be reached
}

async function aggregateRiskyData() {
  const iter = riskyGenerator();
  try {
    const result = await iter.reduce((acc, val) => acc + val, 0);
    console.log('Result:', result);
  } catch (error) {
    console.error('Caught an error during aggregation:', error.message);
  }
}

aggregateRiskyData();
/*
Expected Output:
Caught an error during aggregation: Something went wrong during generation!
*/
            

              
                Copy
              
            
          

உங்கள் பயன்பாடுகள் நிலையானதாக இருப்பதை உறுதிசெய்ய, உங்கள் இட்டரேட்டர் குழாய்களைச் சுற்றி, குறிப்பாக வெளிப்புற அல்லது கணிக்க முடியாத தரவு மூலங்களைக் கையாளும் போது, வலுவான பிழை கையாளுதலைச் செயல்படுத்தவும்.

உலகளாவிய தாக்கம் மற்றும் இட்டரேட்டர் ஹெல்பர்களின் எதிர்காலம்

இட்டரேட்டர் ஹெல்பர்களின் அறிமுகம், குறிப்பாக `reduce()`, ஜாவாஸ்கிரிப்டில் ஒரு சிறிய சேர்த்தல் மட்டுமல்ல; இது உலகெங்கிலும் உள்ள டெவலப்பர்கள் தரவு செயலாக்கத்தை எவ்வாறு அணுகலாம் என்பதில் ஒரு குறிப்பிடத்தக்க முன்னேற்றத்தைக் குறிக்கிறது. இப்போது நிலை 3 இல் உள்ள இந்த முன்மொழிவு, அனைத்து ஜாவாஸ்கிரிப்ட் சூழல்களிலும் – உலாவிகள், Node.js மற்றும் பிற இயக்க நேரங்களிலும் ஒரு நிலையான அம்சமாக மாறத் தயாராக உள்ளது, இது பரந்த அணுகல்தன்மை மற்றும் பயன்பாட்டை உறுதி செய்கிறது.

உலகளவில் டெவலப்பர்களுக்கு அதிகாரம் அளித்தல்

பெரிய அளவிலான பயன்பாடுகள், நிகழ்நேர பகுப்பாய்வுகள் அல்லது பல்வேறு தரவு ஸ்ட்ரீம்களுடன் ஒருங்கிணைக்கும் அமைப்புகளில் பணிபுரியும் டெவலப்பர்களுக்கு, Iterator.prototype.reduce() ஒரு உலகளாவிய மற்றும் திறமையான ஒருங்கிணைப்பு பொறிமுறையை வழங்குகிறது. நீங்கள் டோக்கியோவில் ஒரு நிதி வர்த்தக தளத்தை உருவாக்குகிறீர்களா, பெர்லினில் ஒரு IoT தரவு உட்கொள்ளும் குழாயை உருவாக்குகிறீர்களா, அல்லது சாவோ பாலோவில் ஒரு உள்ளூர்மயமாக்கப்பட்ட உள்ளடக்க விநியோக நெட்வொர்க்கை உருவாக்குகிறீர்களா, ஸ்ட்ரீம் ஒருங்கிணைப்பின் கொள்கைகள் அப்படியே இருக்கின்றன. இந்த ஹெல்பர்கள் பிராந்திய எல்லைகளைத் தாண்டிய ஒரு தரப்படுத்தப்பட்ட, செயல்திறன் மிக்க கருவித்தொகுப்பை வழங்குகின்றன, இது சிக்கலான தரவு ஓட்டங்களுக்கு சுத்தமான, அதிக பராமரிக்கக்கூடிய குறியீட்டை செயல்படுத்துகிறது.

map, filter, reduce போன்ற முறைகள் அனைத்து இட்டரபிள் வகைகளிலும் கிடைப்பதால் ஏற்படும் நிலைத்தன்மை கற்றல் வளைவுகளை எளிதாக்குகிறது மற்றும் சூழல் மாற்றத்தைக் குறைக்கிறது. டெவலப்பர்கள் வரிசைகள், ஜெனரேட்டர்கள் மற்றும் ஒத்திசைவற்ற ஸ்ட்ரீம்கள் முழுவதும் பழக்கமான செயல்பாட்டு வடிவங்களைப் பயன்படுத்தலாம், இது அதிக உற்பத்தித்திறன் மற்றும் குறைவான பிழைகளுக்கு வழிவகுக்கிறது.

தற்போதைய நிலை மற்றும் உலாவி ஆதரவு

ஒரு நிலை 3 TC39 முன்மொழிவாக, இட்டரேட்டர் ஹெல்பர்கள் ஜாவாஸ்கிரிப்ட் என்ஜின்களில் தீவிரமாக செயல்படுத்தப்படுகின்றன. முக்கிய உலாவிகள் மற்றும் Node.js படிப்படியாக ஆதரவைச் சேர்க்கின்றன. அனைத்து இலக்கு சூழல்களிலும் முழுமையான சொந்த செயலாக்கத்திற்காகக் காத்திருக்கும்போது, டெவலப்பர்கள் பாலிஃபில்களை (core-js நூலகம் போன்றவை) பயன்படுத்தி இன்று இந்த அம்சங்களைப் பயன்படுத்தலாம். இது உடனடி தத்தெடுப்பு மற்றும் நன்மையை அனுமதிக்கிறது, இது எதிர்காலத்திற்கு ஏற்ற குறியீட்டை உறுதி செய்கிறது, இது சொந்த செயலாக்கங்களுக்கு தடையின்றி மாறும்.

ஜாவாஸ்கிரிப்ட்டிற்கான ஒரு பரந்த பார்வை

இட்டரேட்டர் ஹெல்பர்ஸ் முன்மொழிவு, ஜாவாஸ்கிரிப்டின் செயல்பாட்டு, அறிவிப்பு மற்றும் ஸ்ட்ரீம் சார்ந்த நிரலாக்க முன்னுதாரணத்தை நோக்கிய பரந்த பரிணாம வளர்ச்சியுடன் ஒத்துப்போகிறது. தரவுகளின் அளவு தொடர்ந்து அதிகரித்து, பயன்பாடுகள் பெருகிய முறையில் விநியோகிக்கப்பட்டு எதிர்வினையாற்றும்போது, தரவு ஸ்ட்ரீம்களை திறமையாகக் கையாள்வது பேச்சுவார்த்தைக்கு அப்பாற்பட்டதாகிறது. reduce() மற்றும் பிற ஹெல்பர்களை இட்டரேட்டர்களுக்கான முதல் தர குடிமக்களாக மாற்றுவதன் மூலம், ஜாவாஸ்கிரிப்ட் அதன் பரந்த டெவலப்பர் சமூகத்திற்கு மிகவும் வலுவான, அளவிடக்கூடிய மற்றும் பதிலளிக்கக்கூடிய பயன்பாடுகளை உருவாக்க அதிகாரம் அளிக்கிறது, இது வலையிலும் அதற்கு அப்பாலும் சாத்தியமானவற்றின் எல்லைகளைத் தள்ளுகிறது.

முடிவு: ஸ்ட்ரீம் ஒருங்கிணைப்பின் சக்தியைப் பயன்படுத்துதல்

ஜாவாஸ்கிரிப்ட் இட்டரேட்டர் ஹெல்பர் reduce() முறையானது மொழிக்கு ஒரு முக்கியமான மேம்பாட்டைக் குறிக்கிறது, இது எந்தவொரு இட்டரபிள் மூலத்திலிருந்தும் தரவை ஒருங்கிணைக்க ஒரு சக்திவாய்ந்த, நெகிழ்வான மற்றும் நினைவக-திறமையான வழியை வழங்குகிறது. பழக்கமான reduce() வடிவத்தை ஒத்திசைவான மற்றும் ஒத்திசைவற்ற இட்டரேட்டர்களுக்கு விரிவுபடுத்துவதன் மூலம், இது டெவலப்பர்களுக்கு தரவு ஸ்ட்ரீம்களை செயலாக்குவதற்கான ஒரு தரப்படுத்தப்பட்ட கருவியைக் கொடுக்கிறது, அவற்றின் அளவு அல்லது தோற்றத்தைப் பொருட்படுத்தாமல்.

பெரிய தரவுத்தொகுப்புகளுடன் நினைவகப் பயன்பாட்டை மேம்படுத்துவது முதல் பக்கப்படுத்தப்பட்ட APIகளிலிருந்து சிக்கலான ஒத்திசைவற்ற தரவு ஓட்டங்களை நேர்த்தியாகக் கையாள்வது வரை, Iterator.prototype.reduce() ஒரு தவிர்க்க முடியாத கருவியாக தனித்து நிற்கிறது. பிற இட்டரேட்டர் ஹெல்பர்களுடன் அதன் இயற்றக்கூடிய தன்மை அதன் பயன்பாட்டை மேலும் மேம்படுத்துகிறது, இது தெளிவான, அறிவிப்பு தரவு செயலாக்க குழாய்களை உருவாக்க அனுமதிக்கிறது.

உங்கள் அடுத்த தரவு-தீவிர திட்டத்தில் நீங்கள் இறங்கும்போது, இட்டரேட்டர் ஹெல்பர்களை உங்கள் பணிப்பாய்வுக்குள் ஒருங்கிணைக்கக் கருதுங்கள். அதிக செயல்திறன் மிக்க, அளவிடக்கூடிய மற்றும் பராமரிக்கக்கூடிய ஜாவாஸ்கிரிப்ட் பயன்பாடுகளை உருவாக்க ஸ்ட்ரீம் ஒருங்கிணைப்பின் சக்தியைத் தழுவுங்கள். ஜாவாஸ்கிரிப்டில் தரவு செயலாக்கத்தின் எதிர்காலம் இங்கே உள்ளது, மேலும் reduce() அதன் மையத்தில் உள்ளது.